<?php
/**
* Codé par Filament le 8 janvier 2011
* classe catégories. Celle ci est amenée à définir les catégégories qui sont traitées sur dmi et peut être utilisées à plusieurs 
* fin, comme trier les news et les dossier, ou encore faire des recherches communes par catégories, ou associer des styles en 
* fonction de la catégorie. La classe est donc amenée à se développer par la suite.
* 
* Depuis la version 0.4 les catégories sont organisées dans un arbre.
* Les méthodes associées ont été implémantées
* 
* @version 0.4
* @since 08/01/2011
*/

//Et voici la classe qui gère les catégories
//Rien ne doit être modifié en dehors, c'est cette classe qui assure la logique des données dans la bdd
//En revanche on peut ajouter de nombreuses méthodes dans cette classe pour agir depuis l'extérieur
//Respecter l'encapsulation et donc favoriser private !
class Categorie {
	//Les attribut du dossier :
	private $id;
	private $left_id;
	private $right_id;
	private $titre;
	private $titre_court;
	private $logo;
	private $style;
	private $squelette;
	private $parent;
	private $level;
	private $color;

	//Et hop le constructeur :
	public function __construct() {

		//En fonction du nombre d'arguments on ne va pas dans la même fonction :
		$num=func_num_args();

		switch($num) {
			case 1 :
				$tmp_id = func_get_arg(0);
				//PHP 5.3.0 Cette fonction peut maintenant être utilisée dans des listes de paramètres. 
				//Donc on doit faire cette manip pour DMI
				$this->initId($tmp_id);
				break;
			case 6 :
				$titre = func_get_arg(0);
				$logo = func_get_arg(1);
				$style = func_get_arg(2);
				$parent = func_get_arg(3);
				$squelette = func_get_arg(4);
				$color = func_get_arg(5);
				$this->newCat($titre, $logo, $style, $parent, $squelette, $color);
				break;
			case 7 :
				$id = func_get_arg(0);
				$titre = func_get_arg(1);
				$logo = func_get_arg(2);
				$style = func_get_arg(3);
				$parent = func_get_arg(4);
				$squelette = func_get_arg(5);
				$color = func_get_arg(6);
				$this->newCat($titre, $logo, $style, $parent, $squelette, $color, $id);
				break;
			default :
				break;
		}
	}

	//Initialisation de la catégorie en fonction de son id :
	private function initId($id) {
		//On récupère la connexion à la bdd déjà établie :
		global $db;

		//Mais de quelle catégorie peut il bien s'agir ?
		$infos = "SELECT 
						id_cat
						, left_id
						, right_id
						, titre
						, titre_court
						, logo
						, style
						, color
						, parent
						, level
						, squelette
					FROM 
						".CATEGORIES_TABLE."
					WHERE 
						id_cat = '".(int) $id."'
					LIMIT 0,1";

		//Bien et maintenant les résutlats :
		$result = $db->sql_query($infos);
		$infos = $db->sql_fetchrow($result);

		//Plopidou pou => on les stocke dans l'objet !
		$this->id = $infos['id_cat'];
		$this->left_id = $infos['left_id'];
		$this->right_id = $infos['right_id'];
		$this->titre = $infos['titre'];
		$this->titre_court = $infos['titre_court'];
		$this->logo = $infos['logo'];
		$this->style = $infos['style'];
		$this->color = $infos['color'];
		$this->squelette = $infos['squelette'];
		$this->parent = $infos['parent'];
		$this->level = $infos['level'];

		//Mais ? Cette variable prend de la place ! Et j'en ai rien à foutre !
		$db->sql_freeresult($result);
		//Paix à ton ame !

		//yeah mon objet est correctement inialisé !
	}

	//On crée une categorie
	private function newCat($titre, $logo, $style, $parent, $squelette, $color, $id = null) {
		global $db, $infos;

		if($parent != 0) {
			//Primo on récupère le père :
			$papaSQL = "SELECT
						id_cat
						, left_id
						, right_id
						, level
						, squelette
						, style
					FROM
						".CATEGORIES_TABLE."
					WHERE
						id_cat = '".$parent."'
					LIMIT 0,1";
			$papaResult = $db->sql_query($papaSQL);
			$papaData = $db->sql_fetchrow($papaResult);
			$db->sql_freeresult($papaResult);
			
			//Maintenant on décale toutes les bornes de droite :
			$updateDroite = "UPDATE
									".CATEGORIES_TABLE."
							SET
								right_id = right_id + 2
							WHERE
								right_id >= '".$papaData['right_id']."'";
			$db->sql_query($updateDroite);
			
			//Maintenant on décale toutes les bornes de gauche :
			$updateGauche = "UPDATE
									".CATEGORIES_TABLE."
							SET
								left_id = left_id + 2
							WHERE
								left_id >= '".$papaData['right_id']."'";
			$db->sql_query($updateGauche);
			
			//On prépare la requête d'ajout :
			$sql_ary = array(
				'titre' => $titre,
				'left_id' => $papaData['right_id'],
				'right_id' => $papaData['right_id'] + 1,
				'logo' => $logo,
				'style' => (!empty($style)) ? $style : $papaData['style'],
				'parent' => $papaData['id_cat'],
				'squelette' => (!empty($squelette)) ? $squelette : $papaData['squelette'],
				'level' => $papaData['level'] + 1,
			);
		} else {
			//C'est une nouvelle catégorie initiale.
			
			//Dans ce cas je l'ajoute tout à droite.
			$select = "SELECT
							right_id
						FROM
							".CATEGORIES_TABLE."
						WHERE
							parent = 0
						ORDER BY
							left_id DESC
						LIMIT 0,1";
			$max_droiteResult = $db->sql_query($select);
			$max_droite = $db->sql_fetchrow($max_droiteResult);
			$db->sql_freeresult($max_droiteResult);
			
			//On prépare la requête d'ajout :
			$sql_ary = array(
				'titre' => $titre,
				'left_id' => $max_droite['right_id']+1,
				'right_id' => $max_droite['right_id'] + 2,
				'logo' => $logo,
				'style' => $style,
				'parent' => 0,
				'squelette' => $squelette,
				'level' => 0,
			);
		}
		
		//Si jamais un id est précisé ?
		if(isset($id) && $id != null)
			$sql_ary['id_cat'] = $id;

		//On ajoute à la bdd :
		$sql = 'INSERT INTO 
						'.CATEGORIES_TABLE.'
				' . $db->sql_build_array('INSERT', $sql_ary);
		$db->sql_query($sql);

		//On enregistre ça en attribut :
		$this->id = $db->sql_nextid();
		$this->titre = $sql_ary['titre'];
		$this->left_id = $sql_ary['left_id'];
		$this->right_id = $sql_ary['right_id'];
		$this->logo = $sql_ary['logo'];
		$this->style = $sql_ary['style'];
		$this->parent = $sql_ary['parent'];
		$this->squelette = $sql_ary['squelette'];
		$this->level = $sql_ary['level'];
		
		$infos[] = utf8_normalize_nfc('La catégories '.$titre.' a été ajoutée');
	}
	
	//On supprime une catégorie :
	public function deleteCat() {
		global $db;

		//On supprime de la bdd l'élément courant :
		$delete = "DELETE FROM
						".CATEGORIES_TABLE."
					WHERE
						id_cat = '".$this->id."'";
		$db->sql_query($delete);
		
		//On remonte d'un niveau tous les enfants :
		$updateLevel = "UPDATE
								".CATEGORIES_TABLE."
						SET
								level = level - 1
						WHERE
								left_id >= '".$this->left_id."'
						AND
								right_id <= '".$this->right_id."'";
		$db->sql_query($updateLevel);
		
		//Maintenant on décale toutes les bornes de gauche :
		$updateGauche = "UPDATE
								".CATEGORIES_TABLE."
						SET
							left_id = left_id - 2
						WHERE
							left_id >= '".$this->left_id."'";
		$db->sql_query($updateGauche);
		
		//Et pour finir on décale toutes les bornes de droite :
		$updateDroite = "UPDATE
								".CATEGORIES_TABLE."
						SET
							right_id = right_id - 2
						WHERE
							right_id >= '".$this->left_id."'";
		$db->sql_query($updateDroite);

		//Bien on a supprimé l'élément de la base de données.
		$infos[] = utf8_normalize_nfc('La catégories '.$this->titre.' a été supprimée');
	}
	

	//Maintenant les accesseurs :
	//On ne fait pas de setter puisque ceux ci sont entièrement géré par la base de données, ou lors de la création d'un 		// dossier, il est donc nécessairee pour des questions de sécurité de ne pas fournir d'API qui modifie les données des 		// dossiers

	//Donc les Getters :

	public function getId() {
		return $this->id;
	}

	public function getTitre() {
		return $this->titre;
	}

	public function getLogo() {
		return $this->logo;
	}

	public function getParent() {
		return $this->parent;
	}
	
	public function getFilAriane() {
		if($this->parent != 0) {
			$parent = new Categorie($this->parent);
			$fil = $parent->getFilAriane() . ' -> ' . '<a href="liste_dossiers.php?cat='.$this->id.'">'.$this->titre.'</a>';
		}
		else
			$fil = '<a href="liste_dossiers.php?cat='.$this->id.'">'.$this->titre.'</a>';
		return $fil;
	}
	
	public function getTop() {
		if($this->level > 1) {
			$parent = new Categorie($this->parent);
		}
		else
			return $this->titre_court;
	}

	public function getSquelette() {
		return $this->squelette;
	}

	public function getStyle() {
		return $this->style;
	}
	
	public function getColor() {
		return $this->color;
	}
}

/**
 * Cette fonction donne la liste ordonnée des catégories utlisées sur DMI
 * @var $start Si on ne veut pas toutes les catégories, mais juste un bout de l'arbre, indiquer ici le noeud de départ
 */
function listCategories($start = null) {
	global $db, $template;
	
	//On prépare la requête :
	$sql_array = array(
		'SELECT'	=> 'id_cat, level, titre, logo',
		'FROM'		=> array( CATEGORIES_TABLE => 'nc1'),
		'ORDER_BY' 	=> 'left_id'
	);
	
	//Est ce que l'on limite à un sous arbre ?
	if($start != null) {
		//On ajoute la jointure :
		$sql_array['FROM'][] = array(CATEGORIES_TABLE, 'nc2');
		$sql_array['WHERE'] = 'nc2.id_cat = '.$start.' 
								AND nc1.left_id >= nc2.left_id
								AND nc1_right_id <= nc2.right_id';
	}
	
	//On construit la requête maintenant :
	$cats = $db->sql_build_query('SELECT', $sql_array);
	
	//Level max, initialité à 0 :
	$levelMax = 0;
	
	//Et on exécute la requête :
	$result = $db->sql_query($cats);
	while($cat = $db->sql_fetchrow($result)) {
		$espace = '';
		//Je prépare la tabulation :
		for($i = 0; $i < $cat['level']; $i++)
			$espace .= '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
		$template->assign_block_vars('list_cats', array(
			'CAT_ID'		=> $cat['id_cat'],
			'LOGO'			=> $cat['logo'],
			'TITRE'			=> $cat['titre'],
			'TITRE_TAB'		=> $espace.$cat['titre'],
			'TAB'			=> $espace
		));
		
		//On met à jour le level max :
		if($levelMax < $cat['level'])
			$levelMax = $cat['level'];
	}
	
	$template->assign_var('LEVEL_MAX', $levelMax+1);
}
?>
